# import packages

import pandas as pd
import numpy as np
import json
import math
import matplotlib
from datetime import timedelta, datetime
import matplotlib.pyplot as plt
import matplotlib.mlab as mlab
from matplotlib.pyplot import figure
from datetime import date

import plotly.express as px
from plotly.subplots import make_subplots
import plotly.graph_objects as go


plt.style.use('seaborn-v0_8-notebook')
%matplotlib inline
matplotlib.rcParams['figure.figsize'] = (12,8)
pd.options.mode.chained_assignment = None
import seaborn as sns

# Einlesen von Daten
df = pd.read_csv("CarPrice_Assignment.csv")
door_mapCt=0     # um mehrfach map zu vermeiden
door_mapCt1=0  # um mehrfach map zu vermeiden
pd.set_option('display.max_columns', None) # zeigt alle Spalten an

# Ein Überblick über die Daten mit df.head()
df.head()

# zeige die kompakte Information über die Daten
df.info()

<class 'pandas.core.frame.DataFrame'>
Index: 203 entries, 0 to 204
Data columns (total 28 columns):
 #   Column            Non-Null Count  Dtype  
---  ------            --------------  -----  
 0   car_ID            203 non-null    int64  
 1   symboling         203 non-null    int64  
 2   CarName           203 non-null    object 
 3   fueltype          203 non-null    object 
 4   aspiration        203 non-null    object 
 5   doornumber        203 non-null    int64  
 6   carbody           203 non-null    object 
 7   drivewheel        203 non-null    object 
 8   enginelocation    203 non-null    object 
 9   wheelbase         203 non-null    float64
 10  carlength         203 non-null    float64
 11  carwidth          203 non-null    float64
 12  carheight         203 non-null    float64
 13  curbweight        203 non-null    int64  
 14  enginetype        203 non-null    object 
 15  cylindernumber    203 non-null    int64  
 16  enginesize        203 non-null    int64  
 17  fuelsystem        203 non-null    object 
 18  boreratio         203 non-null    float64
 19  stroke            203 non-null    float64
 20  compressionratio  203 non-null    float64
 21  horsepower        203 non-null    int64  
 22  peakrpm           203 non-null    int64  
 23  citympg           203 non-null    int64  
 24  highwaympg        203 non-null    int64  
 25  price             203 non-null    float64
 26  brand             203 non-null    object 
 27  model             203 non-null    object 
dtypes: float64(8), int64(10), object(10)
memory usage: 54.1+ KB

# Prüfen wie viele Nan jeder Spalte gibt: zwar df.info() hat gezeigt es keine NAN gibt. es ist üblich df.isna().sum() auch mal zu benutzen
# df.isnull().sum()
df.isna().sum()

car_ID              0
symboling           0
CarName             0
fueltype            0
aspiration          0
doornumber          0
carbody             0
drivewheel          0
enginelocation      0
wheelbase           0
carlength           0
carwidth            0
carheight           0
curbweight          0
enginetype          0
cylindernumber      0
enginesize          0
fuelsystem          0
boreratio           0
stroke              0
compressionratio    0
horsepower          0
peakrpm             0
citympg             0
highwaympg          0
price               0
dtype: int64

# zeige welche Anzahl von Tür ein Auto hat. z.B. 2,3,5 
# zeige auch die Anzahl von Autos  von 2 und 4 Türen
print(df.doornumber.unique())
print(df.groupby(['doornumber']).count())
df.groupby(['doornumber']).mean(numeric_only=True)

['two' 'four']
            car_ID  symboling  CarName  fueltype  aspiration  carbody  \
doornumber                                                              
four           115        115      115       115         115      115   
two             90         90       90        90          90       90   

            drivewheel  enginelocation  wheelbase  carlength  carwidth  \
doornumber                                                               
four               115             115        115        115       115   
two                 90              90         90         90        90   

            carheight  curbweight  enginetype  cylindernumber  enginesize  \
doornumber                                                                  
four              115         115         115             115         115   
two                90          90          90              90          90   

            fuelsystem  boreratio  stroke  compressionratio  horsepower  \
doornumber                                                                
four               115        115     115               115         115   
two                 90         90      90                90          90   

            peakrpm  citympg  highwaympg  price  
doornumber                                       
four            115      115         115    115  
two              90       90          90     90

# zeige welche Zylinder Kategorie es gibt
df.cylindernumber.unique()

array(['four', 'six', 'five', 'three', 'twelve', 'two', 'eight'],
      dtype=object)

# wie schon erwähnt. es ist sinnvoll, Anzahl von Tür und Zylinder in Zahl umzuwandeln
map_list= {'two':2,'three':3,'four':4, 'five':5,'six':6,'eight':8,'twelve':12}
if( door_mapCt1==0): #verhindern nochmaliges Umwandeln
  df['cylindernumber'] = df['cylindernumber'].map(map_list).astype(int)
  df['doornumber'] = df['doornumber'].map(map_list).astype(int)

door_mapCt1=1
print(df.cylindernumber)
print(df.doornumber)

0      4
1      4
2      6
3      4
4      5
      ..
200    4
201    4
202    6
203    6
204    4
Name: cylindernumber, Length: 205, dtype: int64
0      2
1      2
2      2
3      4
4      4
      ..
200    4
201    4
202    4
203    4
204    4
Name: doornumber, Length: 205, dtype: int64

# zeige die statistische Zusammenfassung
df.describe()

# Überblick über die Anzahl der eindeutigen Werte
df.nunique()

car_ID              205
symboling             6
CarName             147
fueltype              2
aspiration            2
doornumber            2
carbody               5
drivewheel            3
enginelocation        2
wheelbase            53
carlength            75
carwidth             44
carheight            49
curbweight          171
enginetype            7
cylindernumber        7
enginesize           44
fuelsystem            8
boreratio            38
stroke               37
compressionratio     32
horsepower           59
peakrpm              23
citympg              29
highwaympg           30
price               189
dtype: int64

# Feature engneering: 
# Histogram für numerische Werte erstellen und darstellen
numerical_columns = ['symboling','doornumber','cylindernumber','wheelbase', 'carlength', 'carwidth', 'carheight', 'curbweight',
                     'enginesize', 'boreratio', 'stroke', 'compressionratio', 'horsepower',
                     'peakrpm', 'citympg', 'highwaympg']

cols = 5
rows = int(np.ceil(len(numerical_columns) / cols))

fig = make_subplots(rows=rows, cols=cols, subplot_titles=numerical_columns)

for i, feature in enumerate(numerical_columns):
    row = i // cols + 1
    col = i % cols + 1

    fig.add_trace(
    go.Histogram(
        x=df[feature],
        nbinsx=25,
        name=feature,
        marker=dict(
            line=dict(
                color='black',  # Linienfarbe
                width=1         # Liniendicke
            )
        )
    ),
    row=row, col=col
    )


fig.update_layout(
    height=300 * rows,
    width=1400,
    title_text="Histogramme der numerischen Features",
    showlegend=False
)

fig.show()

# Analyse von Preis: Histogram für Preise

print("-- Überblick über statistische Werte von Preis --")

print("min.:", df['price'].min())
print("max.:",df['price'].max())
print("mean:",df['price'].mean())
print("median:",df['price'].median())


fig = px.histogram(df, x='price', nbins=40, marginal="rug", title='Distribution of Price', opacity=0.8)

fig.update_layout(
    xaxis_title='Price',
    yaxis_title='Count',
    height=600  # Höhe des Plots
)

fig.update_xaxes(
    tickmode='linear',
    tick0=0,
    dtick=2000
)

fig.show()

-- Überblick über statistische Werte von Preis --
min.: 5118.0
max.: 45400.0
mean: 13276.710570731706
median: 10295.0

print(df['fuelsystem'].unique())
print(df['enginetype'].unique())
print(df['carbody'].unique())

['mpfi' '2bbl' 'mfi' '1bbl' 'spfi' '4bbl' 'idi' 'spdi']
['dohc' 'ohcv' 'ohc' 'l' 'rotor' 'ohcf' 'dohcv']
['convertible' 'hatchback' 'sedan' 'wagon' 'hardtop']

import plotly.subplots as sp

categorical_columns = ['fueltype', 'aspiration', 'carbody', 'drivewheel',
                       'enginelocation', 'enginetype', 'fuelsystem']

df_cat = df.copy()
for c in categorical_columns:
    df_cat[c] = (df_cat[c].astype('string').str.strip().fillna('dl'))

fig = sp.make_subplots(rows=3, cols=3,
    subplot_titles=[col.capitalize() for col in categorical_columns])

row, col = 1, 1
for column in categorical_columns:
    vc = (df_cat[column]
          .value_counts(dropna=False)   # alle mitnehmen
          .sort_index())                # fixe Reihenfolge (oder sort_values())

    cats = list(map(str, vc.index))     # Kategorien als Strings

    fig.add_trace(
        go.Bar(x=cats, y=vc.values, name=column),
        row=row, col=col
    )

    fig.update_xaxes(
        type='category',
        title_text=column.capitalize(),
        categoryorder="array",
        categoryarray=cats,
        tickangle=45,
        row=row, col=col
    )
    fig.update_yaxes(title_text="Count", row=row, col=col)

    col += 1
    if col > 3:
        col = 1
        row += 1

fig.update_layout(height=900, width=1300, showlegend=False,
                  title_text="Categorical Features Count Plots",
                  bargap=0.15)
fig.show()

n = 20  # Number of top car models to plot
top_car_models = df['CarName'].value_counts().head(n)

plt.figure(figsize=(10, 6))
sns.barplot(x=top_car_models.values, y=top_car_models.index)
plt.title(f'Top {n} Car Models by Frequency')
plt.xlabel('Frequency')
plt.ylabel('Car Model')
plt.tight_layout()
plt.show()

# Calculate average price for each car model
avg_prices_by_car = df.groupby('CarName')['price'].mean().sort_values(ascending=False)

# Plot top N car models by average price
n = 20  # Number of top car models to plot
top_car_models = avg_prices_by_car.head(n)

plt.figure(figsize=(10, 6))
sns.barplot(x=top_car_models.values, y=top_car_models.index)
plt.title(f'Top {n} Car Models by Average Price')
plt.xlabel('Average Price')
plt.ylabel('Car Model')
plt.tight_layout()
plt.show()

# Calculate average price for each car model
avg_prices_by_car = df.groupby('CarName')['price'].mean().sort_values(ascending=True)

# Plot top N car models by average price
n = 20 
top_car_models = avg_prices_by_car.head(n)

plt.figure(figsize=(10, 6))
sns.barplot(x=top_car_models.values, y=top_car_models.index)
plt.title(f' Cheapest {n} Car Models by Average Price')
plt.xlabel('Average Price')
plt.ylabel('Car Model')
plt.tight_layout()
plt.show()

import plotly.graph_objects as go
from plotly.subplots import make_subplots
from math import ceil

# Categorical Feature vs. Price
n_cols = 3
n_rows = ceil(len(categorical_columns) / n_cols)

fig = make_subplots(rows=n_rows, cols=n_cols, subplot_titles=categorical_columns)

for idx, feature in enumerate(categorical_columns):
    row = idx // n_cols + 1
    col = idx % n_cols + 1
    
    # Einzelner Boxplot mit plotly.express erzeugen
    box_fig = px.box(df, x=feature, y='price', points='outliers', color_discrete_sequence=["blue"])
    
    # Traces in die Subplots einfügen
    for trace in box_fig.data:
        fig.add_trace(trace, row=row, col=col)

fig.update_layout(height=450 * n_rows, width=500 * n_cols, showlegend=False)
fig.show()

# jeder Werte zeigen, ähnlich wie histogramm (Werte aber zusammenfasst)

numerical_columns = ['symboling','doornumber','cylindernumber','wheelbase', 'carlength', 'carwidth', 'carheight', 'curbweight',
                     'enginesize', 'boreratio', 'stroke', 'compressionratio', 'horsepower',
                     'peakrpm', 'citympg', 'highwaympg']

single_color = 'blue'  # eine Farbe für alle Plots

fig = make_subplots(
    rows=8, cols=2,
    subplot_titles=[col.capitalize() for col in numerical_columns],
    horizontal_spacing=0.05,  # engerer horizontaler Abstand
    vertical_spacing=0.08
)

row, col = 1, 1
for col_name in numerical_columns:
    counts = df[col_name].value_counts().reset_index()
    counts.columns = [col_name, 'Count']

    fig.add_trace(
        go.Bar(
            x=counts[col_name],
            y=counts['Count'],
            text=counts['Count'],
            textposition='outside',
            marker_color=single_color
         
        ),
        row=row, col=col
    )

    col += 1
    if col > 2:  # nur 2 Spalten
        col = 1
        row += 1

fig.update_layout(
    height=2200, width=1600,  # Höhe und Breite anpassen
    title_text="Count Plots of Numerical Columns",
    showlegend=False
)

fig.show()

# Feuture engineering for numerical_columns: Scatter plot

numerical_columns = ['doornumber','cylindernumber','wheelbase', 'carlength', 'carwidth', 'carheight', 'curbweight',
                     'enginesize', 'boreratio', 'stroke', 'compressionratio', 'horsepower',
                     'peakrpm', 'citympg', 'highwaympg']

target = 'price'
# Annahme: df ist dein DataFrame und features_for_scatter deine Liste der Features
# Beispielhafte Berechnung der Achsenbereiche, wie zuvor bestimmt (hier musst du ggf. deine realen Daten nutzen)
features_for_scatter = [f for f in numerical_columns if f != target]
print(features_for_scatter)
feature_ranges = {
    feature: (df[feature].min(), df[feature].max()) for feature in features_for_scatter
}

# Subplot-Layout mit 3 Spalten und entsprechender Zeilenanzahl
num_features = len(features_for_scatter)
num_cols = 3
num_rows = (num_features + num_cols - 1) // num_cols

fig = make_subplots(
    rows=num_rows, cols=num_cols,
    subplot_titles=[f"{feat} vs {target}" for feat in features_for_scatter],
    vertical_spacing=0.08  # Weniger Abstand zwischen den Reihen
)

#fig = make_subplots(rows=num_rows, cols=num_cols,subplot_titles=[f"{feat} vs {target}" for feat in features_for_scatter])

for i, feature in enumerate(features_for_scatter):
    row = i // num_cols + 1
    col = i % num_cols + 1
    # 5% Padding links und rechts für x-Achse
    x_min, x_max = feature_ranges[feature]
    x_range_pad = (x_max - x_min) * 0.05
    x_axis_range = [x_min - x_range_pad, x_max + x_range_pad]

    scatter = go.Scatter(x=df[feature], y=df[target], mode='markers', name=feature)
    fig.add_trace(scatter, row=row, col=col)

    # Setze die x-Achse des Subplots mit Range und angemessener Tick-Anzahl
    fig.update_xaxes(range=x_axis_range, row=row, col=col, nticks=5)

    # Label für jede Achse hinzufügen (optional)
    fig.update_xaxes(title_text=feature, row=row, col=col)
    fig.update_yaxes(title_text=target, row=row, col=col)

# Layout anpassen: Grösse, Abstand, Titel
fig.update_layout(height=300*num_rows, width=1300,  # statt 1000 jetzt 1200 für +20%
                  title_text="Scatterplots Features vs. price (3 Spalten Layout)",
                  showlegend=False,
                  margin=dict(l=40, r=40, t=80, b=40))


fig.show()

['doornumber', 'cylindernumber', 'wheelbase', 'carlength', 'carwidth', 'carheight', 'curbweight', 'enginesize', 'boreratio', 'stroke', 'compressionratio', 'horsepower', 'peakrpm', 'citympg', 'highwaympg']

# correlation map for numerical_columns:
numerical_columns1 = ['doornumber','cylindernumber','wheelbase', 'carlength', 'carwidth', 'carheight', 'curbweight',
                     'enginesize', 'boreratio', 'stroke', 'compressionratio', 'horsepower',
                     'peakrpm', 'citympg', 'highwaympg','price']

correlation_matrix = df[numerical_columns1].corr().round(2)
# Heatmap mit Plotly Express
fig = px.imshow(
    correlation_matrix,
    text_auto=True,         # Werte direkt in die Zellen schreiben
    color_continuous_scale='RdBu_r',  # entspricht 'coolwarm'
    title="Correlation Heatmap"
)
fig.update_layout(width=1200, height=1200)
fig.show()

#sns.pairplot(df)

# # Analyse von citympg und highwaympg:

print("-- statistische Werte von highwaympg --")

print("min.:", df['highwaympg'].min())
print("max.:",df['highwaympg'].max())
print("mean:",df['highwaympg'].mean())
print("median:",df['highwaympg'].median())
print("std:",df['highwaympg'].std())
print("6*std:",3*df['highwaympg'].std())

fig = px.histogram(df, x='highwaympg', nbins=30, marginal="rug", title='Distribution of highwaympg', opacity=0.8)

fig.update_layout(
    xaxis_title='highwaympg',
    yaxis_title='Count',    
    height=600  # Höhe des Plots
)

fig.update_xaxes(
    tickmode='linear',
    tick0=0,
    dtick=1  # Tick-Beschriftungen alle 2 Einheiten
)
fig.show()

print("-- statistische Werte von citympg --")

print("min.:", df['citympg'].min())
print("max.:",df['citympg'].max())
print("mean:",df['citympg'].mean())
print("median:",df['citympg'].median())
print("std:",df['citympg'].std())
print("6*std:",3*df['citympg'].std())

fig = px.histogram(df, x='citympg', nbins=30, marginal="rug", title='Distribution of citympg', opacity=0.8)

fig.update_layout(
    xaxis_title='citympg',
    yaxis_title='Count',    
    height=600  # Höhe des Plots
)

fig.update_xaxes(
    tickmode='linear',
    tick0=0,
    dtick=1  # Tick-Beschriftungen alle 2 Einheiten
)
fig.show()

-- statistische Werte von highwaympg --
min.: 16
max.: 54
mean: 30.75121951219512
median: 30.0
std: 6.886443130941824
6*std: 20.659329392825473

-- statistische Werte von citympg --
min.: 13
max.: 49
mean: 25.21951219512195
median: 24.0
std: 6.542141653001622
6*std: 19.626424959004865

# werden später beim Modelltraining benutzt
limit_highwaympg_r=52
limit_highwaympg_l=10

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 205 entries, 0 to 204
Data columns (total 26 columns):
 #   Column            Non-Null Count  Dtype  
---  ------            --------------  -----  
 0   car_ID            205 non-null    int64  
 1   symboling         205 non-null    int64  
 2   CarName           205 non-null    object 
 3   fueltype          205 non-null    object 
 4   aspiration        205 non-null    object 
 5   doornumber        205 non-null    int64  
 6   carbody           205 non-null    object 
 7   drivewheel        205 non-null    object 
 8   enginelocation    205 non-null    object 
 9   wheelbase         205 non-null    float64
 10  carlength         205 non-null    float64
 11  carwidth          205 non-null    float64
 12  carheight         205 non-null    float64
 13  curbweight        205 non-null    int64  
 14  enginetype        205 non-null    object 
 15  cylindernumber    205 non-null    int64  
 16  enginesize        205 non-null    int64  
 17  fuelsystem        205 non-null    object 
 18  boreratio         205 non-null    float64
 19  stroke            205 non-null    float64
 20  compressionratio  205 non-null    float64
 21  horsepower        205 non-null    int64  
 22  peakrpm           205 non-null    int64  
 23  citympg           205 non-null    int64  
 24  highwaympg        205 non-null    int64  
 25  price             205 non-null    float64
dtypes: float64(8), int64(10), object(8)
memory usage: 41.8+ KB

# separate brand and model 
split_cols = df['CarName'].str.split(' ', n=1, expand=True)
# Spalten zuordnen
df['brand'] = split_cols[0]        # erstes Wort
df['model'] = split_cols[1]  
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 205 entries, 0 to 204
Data columns (total 28 columns):
 #   Column            Non-Null Count  Dtype  
---  ------            --------------  -----  
 0   car_ID            205 non-null    int64  
 1   symboling         205 non-null    int64  
 2   CarName           205 non-null    object 
 3   fueltype          205 non-null    object 
 4   aspiration        205 non-null    object 
 5   doornumber        205 non-null    int64  
 6   carbody           205 non-null    object 
 7   drivewheel        205 non-null    object 
 8   enginelocation    205 non-null    object 
 9   wheelbase         205 non-null    float64
 10  carlength         205 non-null    float64
 11  carwidth          205 non-null    float64
 12  carheight         205 non-null    float64
 13  curbweight        205 non-null    int64  
 14  enginetype        205 non-null    object 
 15  cylindernumber    205 non-null    int64  
 16  enginesize        205 non-null    int64  
 17  fuelsystem        205 non-null    object 
 18  boreratio         205 non-null    float64
 19  stroke            205 non-null    float64
 20  compressionratio  205 non-null    float64
 21  horsepower        205 non-null    int64  
 22  peakrpm           205 non-null    int64  
 23  citympg           205 non-null    int64  
 24  highwaympg        205 non-null    int64  
 25  price             205 non-null    float64
 26  brand             205 non-null    object 
 27  model             203 non-null    object 
dtypes: float64(8), int64(10), object(10)
memory usage: 45.0+ KB

nan_rows = df[df.isna().any(axis=1)].index
print(nan_rows)

Index([138, 141], dtype='int64')

df = df.fillna("dl")
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 205 entries, 0 to 204
Data columns (total 28 columns):
 #   Column            Non-Null Count  Dtype  
---  ------            --------------  -----  
 0   car_ID            205 non-null    int64  
 1   symboling         205 non-null    int64  
 2   CarName           205 non-null    object 
 3   fueltype          205 non-null    object 
 4   aspiration        205 non-null    object 
 5   doornumber        205 non-null    int64  
 6   carbody           205 non-null    object 
 7   drivewheel        205 non-null    object 
 8   enginelocation    205 non-null    object 
 9   wheelbase         205 non-null    float64
 10  carlength         205 non-null    float64
 11  carwidth          205 non-null    float64
 12  carheight         205 non-null    float64
 13  curbweight        205 non-null    int64  
 14  enginetype        205 non-null    object 
 15  cylindernumber    205 non-null    int64  
 16  enginesize        205 non-null    int64  
 17  fuelsystem        205 non-null    object 
 18  boreratio         205 non-null    float64
 19  stroke            205 non-null    float64
 20  compressionratio  205 non-null    float64
 21  horsepower        205 non-null    int64  
 22  peakrpm           205 non-null    int64  
 23  citympg           205 non-null    int64  
 24  highwaympg        205 non-null    int64  
 25  price             205 non-null    float64
 26  brand             205 non-null    object 
 27  model             205 non-null    object 
dtypes: float64(8), int64(10), object(10)
memory usage: 45.0+ KB

# originale Daten sichern, für weitere Modellevariante
df_cp= df.copy(deep= True)
df

# Define categorical and numerical columns
categorical_columns = ['fueltype', 'aspiration',  'carbody', 'drivewheel',
                       'enginelocation', 'enginetype', 'fuelsystem', 'brand', 'model']
numerical_columns = ['symboling', 'doornumber','cylindernumber','wheelbase', 'carlength', 'carwidth', 'carheight',
                     'curbweight', 'enginesize', 'boreratio', 'stroke', 'compressionratio', 'horsepower',
                     'peakrpm', 'citympg', 'highwaympg']

print(df["fueltype"].unique(), df["aspiration"].unique(),  df["carbody"].unique(), df["drivewheel"].unique(), df["enginelocation"].unique(), 
      df["enginetype"].unique(), df["fuelsystem"].unique())

print(df["enginesize"].unique())

['gas' 'diesel'] ['std' 'turbo'] ['convertible' 'hatchback' 'sedan' 'wagon' 'hardtop'] ['rwd' 'fwd' '4wd'] ['front' 'rear'] ['dohc' 'ohcv' 'ohc' 'l' 'rotor' 'ohcf' 'dohcv'] ['mpfi' '2bbl' 'mfi' '1bbl' 'spfi' '4bbl' 'idi' 'spdi']
[130 152 109 136 131 108 164 209  61  90  98 122 156  92  79 110 111 119
 258 326  91  70  80 140 134 183 234 308 304  97 103 120 181 151 194 203
 132 121 146 171 161 141 173 145]

scaler = StandardScaler()
df_cp[numerical_columns] = scaler.fit_transform(df_cp[numerical_columns])

from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
import pandas as pd
import numpy as np

def training_carmodel(df_cp, categorical_columns, numerical_columns,
                      encoding_mode=2, test_daten_size=0.2, squared_cols=0):
    """
    Trainiert ein lineares Regressionsmodell auf Auto-Daten.

    Parameters:
    -----------
    df_cp : pd.DataFrame
        Trainingsdaten inklusive Zielspalte 'price'.
    categorical_columns : list
        Liste der kategorialen Spalten.
    numerical_columns : list
        Liste der numerischen Spalten.
    encoding_mode : int
        1 = One-Hot Encoding, 2 = Ordinal (Label) Encoding
    test_daten_size : float
        Anteil der Daten für den Testsplit.
    squared_cols : int
        0 = keine Transformation, 1 = sqrt Transformation, 2 = quadrieren

    Returns:
    --------
    model : LinearRegression
        Trainiertes Regressionsmodell
    label_encoders : dict
        Dictionary mit LabelEncodern für jede kategoriale Spalte (nur bei encoding_mode=2)
    scaler : StandardScaler
        Scaler für numerische Spalten
    mse : float
        Mean Squared Error auf Testdaten
    r2_square : float
        R^2 Score auf Testdaten
    pred_df : pd.DataFrame
        Vergleich von tatsächlichen und vorhergesagten Preisen
    """

    # ----------------------
    # Encoding
    # ----------------------
    if encoding_mode == 1:
        df_cp = pd.get_dummies(df_cp, columns=categorical_columns, drop_first=True)
        label_encoders = None
    else:
        label_encoders = {}
        for column in categorical_columns:
            le = LabelEncoder()
            df_cp[column] = le.fit_transform(df_cp[column])
            label_encoders[column] = le

    # ----------------------
    # Feature Engineering
    # ----------------------
    df_cp['power_to_weight_ratio'] = df_cp['horsepower'] / df_cp['curbweight']
    #df_cp['log_enginesize'] = np.log(df_cp['enginesize'] + 1.2)


    for column in numerical_columns:
        if squared_cols == 2:  #x^2
            df_cp[f'{column}_squared'] = df_cp[column] ** 2
        elif squared_cols == 1:  # sqrt(x)
            df_cp[f'{column}_squared'] = np.where(
                df_cp[column] <= 0,
                -np.sqrt(abs(df_cp[column])),
                np.sqrt(abs(df_cp[column]))
            )

    # ----------------------
    # Scaling
    # ----------------------
    scaler = StandardScaler()
    df_cp[numerical_columns] = scaler.fit_transform(df_cp[numerical_columns])

    # ----------------------
    # Train-Test-Split
    # ----------------------
    X = df_cp.drop(['price', 'car_ID', 'CarName'], axis=1)
    y = df_cp['price']
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_daten_size, random_state=42)

   # print("Rows:", len(df_cp), "columns", len(df_cp.columns) )
    
    # ----------------------
    # Modelltraining
    # ----------------------
    model = LinearRegression()
    model.fit(X_train, y_train)

    # ----------------------
    # Vorhersagen
    # ----------------------
    y_pred = model.predict(X_test)

    # ----------------------
    # Modellbewertung
    # ----------------------
    mse = mean_squared_error(y_test, y_pred)
    r2_square = r2_score(y_test, y_pred)

    pred_df = pd.DataFrame({
        'Actual Value': y_test,
        'Predicted Value': y_pred,
        'Difference': y_test - y_pred,
        'rel%': abs((y_test - y_pred)) / y_test * 100
    })

    #print(f"r2_score: {r2_score:.4f}, MSE: {mse:.2f}")

    return model, label_encoders, scaler, mse, r2_square, pred_df


def predict_price(df_test, model, label_encoders, scaler, categorical_columns, numerical_columns,
                  squared_cols=0):
    """
    Macht Vorhersagen für neue Auto-Daten basierend auf einem trainierten Modell.

    Parameters:
    -----------
    df_test : pd.DataFrame
        Neue Daten zum Vorhersagen
    model : LinearRegression
        Trainiertes Modell
    label_encoders : dict
        LabelEncoder pro kategorialer Spalte (nur bei Ordinal-Encoding)
    scaler : StandardScaler
        Scaler für numerische Spalten
    categorical_columns : list
        Liste der kategorialen Spalten
    numerical_columns : list
        Liste der numerischen Spalten
    squared_cols : int
        0 = keine Transformation, 1 = sqrt Transformation, 2 = quadrieren

    Returns:
    --------
    y_pred : np.ndarray
        Vorhergesagte Preise
    """

    # ----------------------
    # Encoding
    # ----------------------
    if label_encoders is not None:
        for column in categorical_columns:
            df_test[column] = label_encoders[column].transform(df_test[column])

    # ----------------------
    # Feature Engineering
    # ----------------------
    df_test['power_to_weight_ratio'] = df_test['horsepower'] / df_test['curbweight']
    #df_test['log_enginesize'] = np.log(df_test['enginesize'] + 1.2)
 

    for column in numerical_columns:
        if squared_cols == 2:
            df_test[f'{column}_squared'] = df_test[column] ** 2
        elif squared_cols == 1:
            df_test[f'{column}_squared'] = np.where(
                df_test[column] <= 0,
                -np.sqrt(abs(df_test[column])),
                np.sqrt(abs(df_test[column]))
            )

    # ----------------------
    # Scaling
    # ----------------------
    df_test[numerical_columns] = scaler.transform(df_test[numerical_columns])

    # ----------------------
    # Features für Prediction vorbereiten
    # ----------------------
    drop_cols = ['car_ID', 'CarName']
    if 'price' in df_test.columns:
        drop_cols.append('price')
    X_new = df_test.drop(drop_cols, axis=1)

    # ----------------------
    # Prediction
    # ----------------------
    y_pred = model.predict(X_new)
    return y_pred

#One-Hot Encoder
df_cp= df.copy(deep= True)
#training_carmodel(1, test_daten_size=0.2, squared_cols=0)

model, label_encoders, scaler, mse, r2_square, pred_df=  training_carmodel(df_cp, categorical_columns, numerical_columns, 1, test_daten_size=0.2, squared_cols=0)

print(f"r2_score: {r2_square:.4f}, MSE: {mse:.2f}")
print("rel. min.:",pred_df['rel%'].min(), "rel. max.:",pred_df['rel%'].max(), "rel. mean.:",pred_df['rel%'].mean())  

print('\nHistogram: Relativer Prozentsatz der Preisdifferenz bei der Voraussage')
fig = px.histogram(pred_df, x='rel%', nbins=30, height=600,
                   title='Histogramm von rel%',
                   labels={'rel%': 'Rel. Preis-Diff in %'})

fig.show()
fig1 = px.scatter(
    pred_df,
    x='Actual Value',   # oder 'y_test', je nachdem wie deine Spalte heißt
    y='rel%', 
    title='Scatterplot: y_test vs. rel%',
    labels={'Actual Value': 'y_test (echte Werte)', 'rel%': 'Relative Abweichung [%]'},
    opacity=0.7
)

fig1.show()

r2_score: 0.7616, MSE: 18819573.48
rel. min.: 0.5607846455711476 rel. max.: 85.11114714159885 rel. mean.: 29.752253801676417

Histogram: Relativer Prozentsatz der Preisdifferenz bei der Voraussage

#Ordinal Encoder
#categorical colums as ordinal value + numerical columns (standardisiert) -> Linear model

df_cp= df.copy(deep= True)
# mse, r2_square, model, pred_df= training_carmodel(df_cp,2, test_daten_size=0.2,squared_cols=0)
model, label_encoders, scaler, mse, r2_square, pred_df=  training_carmodel(df_cp, categorical_columns, numerical_columns, 2, test_daten_size=0.2, squared_cols=0)

print(f"r2_score: {r2_square:.4f}, MSE: {mse:.2f}")
print("rel. min.:",pred_df['rel%'].min(), "rel. max.:",pred_df['rel%'].max(), "rel. mean.:",pred_df['rel%'].mean())  

print('\nHistogram: Relativer Prozentsatz der Preisdifferenz bei der Voraussage')
fig = px.histogram(pred_df, x='rel%', nbins=30, height=600,
                   title='Histogramm von rel%',
                   labels={'rel%': 'Rel. Preis-Diff in %'})

fig.show()
fig1 = px.scatter(
    pred_df,
    x='Actual Value',   # oder 'y_test', je nachdem wie deine Spalte heißt
    y='rel%', 
    title='Scatterplot: y_test vs. rel%',
    labels={'Actual Value': 'y_test (echte Werte)', 'rel%': 'Relative Abweichung [%]'},
    opacity=0.7
)
fig1.show()

r2_score: 0.8655, MSE: 10614160.91
rel. min.: 0.29296739271161415 rel. max.: 73.32108314015358 rel. mean.: 16.93294809642359

Histogram: Relativer Prozentsatz der Preisdifferenz bei der Voraussage

#Ordinal Encoder
df_cp= df.copy(deep= True)

# entfernen die Zeilen wo  df['highwaympg'] >= limit_highwaympg_r] 
df_cp= df_cp.loc[df_cp['highwaympg'] < limit_highwaympg_r]
model, label_encoders, scaler, mse, r2_square, pred_df=  training_carmodel(df_cp, categorical_columns, numerical_columns, 2, test_daten_size=0.2, squared_cols=0)

print(f"r2_score: {r2_square:.4f}, MSE: {mse:.2f}")
print("rel. min.:",pred_df['rel%'].min(), "rel. max.:",pred_df['rel%'].max(), "rel. mean.:",pred_df['rel%'].mean())  

print('\nHistogram: Relativer Prozentsatz der Preisdifferenz bei der Voraussage')
fig = px.histogram(pred_df, x='rel%', nbins=30, height=600,
                   title='Histogramm von rel%',
                   labels={'rel%': 'Rel. Preis-Diff in %'})
fig.show()

fig1 = px.scatter(
    pred_df,
    x='Actual Value',   # oder 'y_test', je nachdem wie deine Spalte heißt
    y='rel%', 
    title='Scatterplot: y_test vs. rel%',
    labels={'Actual Value': 'y_test (echte Werte)', 'rel%': 'Relative Abweichung [%]'},
    opacity=0.7
)
fig1.show()

r2_score: 0.8755, MSE: 12798736.05
rel. min.: 1.294706571517844 rel. max.: 58.00247721352542 rel. mean.: 15.414618233592236

Histogram: Relativer Prozentsatz der Preisdifferenz bei der Voraussage

import joblib

# Speichern
joblib.dump(model, "linear_model_CarPricePred.pkl")

['linear_model_CarPricePred.pkl']

#Ordinal Encoder
df_cp= df.copy(deep= True)

df_cp= df_cp.loc[df_cp['highwaympg'] < limit_highwaympg_r]
model, label_encoders, scaler, mse, r2_square, pred_df=  training_carmodel(df_cp, categorical_columns, numerical_columns, 2, test_daten_size=0.2, squared_cols=1)

print(f"r2_score: {r2_square:.4f}, MSE: {mse:.2f}")
print("rel. min.:",pred_df['rel%'].min(), "rel. max.:",pred_df['rel%'].max(), "rel. mean.:",pred_df['rel%'].mean())  

print('\nHistogram: Relativer Prozentsatz der Preisdifferenz bei der Voraussage')
fig = px.histogram(pred_df, x='rel%', nbins=30, height=600,
                   title='Histogramm von rel%',
                   labels={'rel%': 'Rel. Preis-Diff in %'})
fig.show()
fig1 = px.scatter(
    pred_df,
    x='Actual Value',   # oder 'y_test', je nachdem wie deine Spalte heißt
    y='rel%', 
    title='Scatterplot: y_test vs. rel%',
    labels={'Actual Value': 'y_test (echte Werte)', 'rel%': 'Relative Abweichung [%]'},
    opacity=0.7
        )
fig1.show()

r2_score: 0.8907, MSE: 11235601.92
rel. min.: 0.11879471355248634 rel. max.: 42.03581058286871 rel. mean.: 14.787747555026515

Histogram: Relativer Prozentsatz der Preisdifferenz bei der Voraussage

df_cp= df.copy(deep= True)
#df_cp.info()
#df= df.loc[df['highwaympg'] < 52 ]
#df= df.loc[df['highwaympg'] < limit_highwaympg_r] # df is cleaned for 'highwaympg'] < limit_highwaympg_r
#df.info()
#df.cylindernumber.unique()

print("fueltype:",df_cp['fueltype'].unique())
print("fuelsystem:",df_cp['fuelsystem'].unique())
print("carbody:",df_cp['carbody'].unique())
print("drivewheel:",df_cp['drivewheel'].unique())
print("enginelocation:", df_cp['enginelocation'].unique())
print("enginetype:",df_cp['enginetype'].unique())
print("brand:",df_cp['brand'].unique())
print("model:",df_cp['model'].unique())


#categorical_columns = ['fueltype', 'aspiration',  'carbody', 'drivewheel','enginelocation', 'enginetype', 'fuelsystem', 'brand', 'model']

fueltype: ['gas' 'diesel']
fuelsystem: ['mpfi' '2bbl' 'mfi' '1bbl' 'spfi' '4bbl' 'idi' 'spdi']
carbody: ['convertible' 'hatchback' 'sedan' 'wagon' 'hardtop']
drivewheel: ['rwd' 'fwd' '4wd']
enginelocation: ['front' 'rear']
enginetype: ['dohc' 'ohcv' 'ohc' 'l' 'rotor' 'ohcf' 'dohcv']
brand: ['alfa-romero' 'audi' 'bmw' 'chevrolet' 'dodge' 'honda' 'isuzu' 'jaguar'
 'maxda' 'mazda' 'buick' 'mercury' 'mitsubishi' 'Nissan' 'nissan'
 'peugeot' 'plymouth' 'porsche' 'porcshce' 'renault' 'saab' 'subaru'
 'toyota' 'toyouta' 'vokswagen' 'volkswagen' 'vw' 'volvo']
model: ['giulia' 'stelvio' 'Quadrifoglio' '100 ls' '100ls' 'fox' '5000' '4000'
 '5000s (diesel)' '320i' 'x1' 'x3' 'z4' 'x4' 'x5' 'impala' 'monte carlo'
 'vega 2300' 'rampage' 'challenger se' 'd200' 'monaco (sw)' 'colt hardtop'
 'colt (sw)' 'coronet custom' 'dart custom' 'coronet custom (sw)' 'civic'
 'civic cvcc' 'accord cvcc' 'accord lx' 'civic 1500 gl' 'accord'
 'civic 1300' 'prelude' 'civic (auto)' 'MU-X' 'D-Max ' 'D-Max V-Cross'
 'xj' 'xf' 'xk' 'rx3' 'glc deluxe' 'rx2 coupe' 'rx-4' '626' 'glc'
 'rx-7 gs' 'glc 4' 'glc custom l' 'glc custom' 'electra 225 custom'
 'century luxus (sw)' 'century' 'skyhawk' 'opel isuzu deluxe' 'skylark'
 'century special' 'regal sport coupe (turbo)' 'cougar' 'mirage' 'lancer'
 'outlander' 'g4' 'mirage g4' 'montero' 'pajero' 'versa' 'gt-r' 'rogue'
 'latio' 'titan' 'leaf' 'juke' 'note' 'clipper' 'nv200' 'dayz' 'fuga'
 'otti' 'teana' 'kicks' '504' '304' '504 (sw)' '604sl' '505s turbo diesel'
 'fury iii' 'cricket' 'satellite custom (sw)' 'fury gran sedan' 'valiant'
 'duster' 'macan' 'panamera' 'cayenne' 'boxter' '12tl' '5 gtl' '99e'
 '99le' '99gle' None 'dl' 'brz' 'baja' 'r1' 'r2' 'trezia' 'tribeca'
 'corona mark ii' 'corona' 'corolla 1200' 'corona hardtop'
 'corolla 1600 (sw)' 'carina' 'mark ii' 'corolla' 'corolla liftback'
 'celica gt liftback' 'corolla tercel' 'corona liftback' 'starlet'
 'tercel' 'cressida' 'celica gt' 'rabbit' '1131 deluxe sedan' 'model 111'
 'type 3' '411 (sw)' 'super beetle' 'dasher' 'rabbit custom' '145e (sw)'
 '144ea' '244dl' '245' '264gl' 'diesel' '246']

#df= df.loc[df['highwaympg'] < limit_highwaympg_r] # df is cleaned for 'highwaympg'] < limit_highwaympg_r
# def training_carmodel(df_cp, categorical_columns, numerical_columns,encoding_mode=2, test_daten_size=0.2, squared_cols=0):

df= df.loc[df['highwaympg'] < 52]
#df.info()
start_price = float(df['price'].min())
end_price = float(df['price'].max())
print(type(start_price))
start_price, end_price

<class 'float'>

(5118.0, 45400.0)

import dash
from dash import Dash, dcc, html, Input, Output, callback
import plotly.express as px
import plotly.graph_objects as go
import json
import pandas as pd


global model_train, label_encoders_train,scaler_train, mse_train, r2_square_train, df_pred_train
global df_train    # copy of orig. df
global df_filtered # filtered df for ineractive modelltraining

row_count=203
df_train= df.copy(deep= True) # df_train is changed after Training 

external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']

app = Dash(__name__, external_stylesheets=external_stylesheets)
styles = {
    'pre': {
        'border': 'thin lightgrey solid',
        'overflowX': 'scroll'
    }
}
slider_value_l=0
slider_value_r=50000
slider_trained_l=0
slider_trained_r=50000

# inital Modelltraining
# entfernen die Zeilen wo  df['highwaympg'] >= limit_highwaympg_r] limit_highwaympg_r=52


model_train, label_encoders_train,scaler_train, mse_train, r2_square_train, df_pred_train =  training_carmodel(df_train, 
                                              categorical_columns, numerical_columns, 2, test_daten_size=0.2, squared_cols=0)

#show the relative deviation of the price : abs(price_diff) / price_orig *100: -> 'rel%': abs((y_test - y_pred)) / y_test * 100
# print("min.:",df_pred_train['rel%'].min(), "max.:",df_pred_train['rel%'].max(), "mean.:",df_pred_train['rel%'].mean())  

my_outstr = (
    f"r2_score: {r2_square_train:.4f},  "
    f"mse: {mse:.4f},  "
    f"min.%: {df_pred_train['rel%'].min():.4f},  "
    f"max.%: {df_pred_train['rel%'].max():.4f},  "
    f"mean%.: {df_pred_train['rel%'].mean():.4f}"
    )
# show original price histogram: go.Histogram() create histogram
# size=300 ist the balkensize, 300 means 300$ for the Bin-width
# height=400 height in pixel, ähnlic wie 'height': '400px' in CSS. aber als string '400px' angegeben.
# for plotly: besser height=400
orig_hist = go.Histogram(
        x=df['price'],
        xbins=dict(
        size=300      # Balkenabstand bzw. Bin-Größe
        ),
        nbinsx=40,
        opacity=0.5,
        name='Original'
    )
fig = go.Figure(orig_hist)

'''
fig.update_layout(
    height=400,   # Höhe in Pixel
    width=800     # optional auch Breite
)
'''
app.layout = html.Div([
    # Erst das Histogramm
    html.Div(
        dcc.Graph(id='compare_histogram', style={ 'width': '100%'}), # 'height':'500px',
        style={'width': '100%', 'padding': '10px'}
    ),

  html.Div(id='result_text', style={'whiteSpace': 'pre-line', 'padding': '10px', 'border': '1px solid #ccc'}),
    # Dann das Slider-DIV darunter
    html.Div([
        #html.Label('Slider Links'),
        dcc.Slider(
            id='price_slider_l',
            min=float(start_price),
            max=float(end_price),
            value=float(start_price),
            step=300.0,
            marks={i: str(i) for i in range(int(start_price), int(end_price)+1, 300)}
        ),

        #html.Label('Slider Rechts'),
        dcc.Slider(
            id='price_slider_r',
            min=float(start_price),
            max=float(end_price),
            value=float(end_price),
            step=300.0,             #300$ a step
            marks={i: str(i) for i in range(int(start_price), int(end_price)+1, 300)}
        )
    ], style={'width': '90%', 'padding': '10px'}),
    
 
    # 2 elements in a DIV: button + histogram
    html.Div([
        html.Div([
             html.Button('Start Training', 
                id='refresh_button', 
                n_clicks=0,
                style={
                        'margin': '10px',
                        'height': '40px',
                        'border': '3px solid black',   # <--- hier wird der Rahmen dicker
                        'borderRadius': '8px'          # optional: abgerundete Ecken
                         }
                       ),

                    dcc.Input(
                        id='output_trained',
                        type='text',
                        #placeholder='10000', 
                        value=my_outstr, 
                        style={'width': '100%'}
                    ),

            
              html.Div(id='alert_message',
              style={
                 'color': 'red',
                 'margin': '10px',
                 'fontWeight': 'bold'
                 
             })
            ], style={'display': 'flex', 'alignItems': 'center'}),

         html.Div([
               dcc.Graph( id='rel_histogram', 
                   figure=go.Figure( data=[go.Histogram(x= df_pred_train['rel%'])],
                   layout=go.Layout(height=400, 
                                    width=700, 
                                    title='Histogram: Die Häufigkeit der rel%-Abweichung',
                                    xaxis_title='Relative Abweichung [%]',
                                    yaxis_title='Häufigkeit'
                                   )
                                 )
                     ),

              dcc.Graph(id='scatter_plot',
                  figure=go.Figure(
                         data=[go.Scatter(
                         x=df_pred_train['Actual Value'],
                         y=df_pred_train['rel%'],
                         mode='markers',
                         opacity=0.7,
                          marker=dict(color='blue')
                         )],
                  layout=go.Layout(
                       height=400,
                       width=400,
                       title='Scatterplot: y_test(Preis in $) vs. rel% Abweichung',
                       xaxis_title='y_test (echte Werte in $)',
                       yaxis_title='Relative Abweichung [%]'
                         )
                        )
                        )


             
                ], style={'display': 'flex', 'alignItems': 'center'} )

        
            ], style={'width': '100%'})

    
      ] , style={'width': '90%', 'margin': 'auto'})


# check if enough rows exist
@app.callback(
    Output('alert_message', 'children'),
    Input('price_slider_l', 'value'),
    Input('price_slider_r', 'value')
)
def validate_inputs(slider_value_l, slider_value_r):
    df_train = df.copy(deep=True)
    
    if slider_value_l > slider_value_r:
       sl_val=slider_value_r
       slider_value_r= slider_value_l
       slider_value_l=  sl_val
        

    df_filtered = df_train[(df_train['price'] >= slider_value_l) & (df_train['price'] <= slider_value_r)]
    row_count = len(df_filtered)

    if row_count < 60:
        return f"⚠️ Achtung: Gefilterte Datenmenge ist zu klein (nur {row_count} Zeilen, benötigt > 60)."

    return ""



@app.callback(
    Output('compare_histogram', 'figure'),
    Output('result_text', 'children'),
    Input('price_slider_l', 'value'),
    Input('price_slider_r', 'value')   
)
def update_compare_histogram(slider_value_l,slider_value_r):
    # Ungefiltertes Histogramm
    # slider_value_l: left value
    # slider_value_r: right value
    import plotly.graph_objects as go
    global df_filtered, row_count

    # why do the copy hier: df_filtered is a part of df_train. they have the same memory area. 
    # wenn f_filtered is changed, then memory of df_train is also changed even if df_train seem to be not be changed
    df_train= df.copy(deep= True)
    if slider_value_l > slider_value_r:
       sl_val=slider_value_r
       slider_value_r= slider_value_l
       slider_value_l=  sl_val
    
    df_filtered = df_train[(df_train['price'] >= slider_value_l) & (df_train['price'] <= slider_value_r)]
    # a0, a1, ...a29: 30 variable to be calculated, row_count should be 60 (48 for training, 12 for testing 
    row_count= len( df_filtered )   
    #print("row_count=", row_count)

    # Gefiltertes Histogramm
    filtered_hist = go.Histogram(
        x=df_filtered['price'],
        xbins=dict(
        size=300      # Balkenabstand bzw. Bin-Größe
        ),       
        opacity=0.7,
        name=f'Gefiltert ab {slider_value_l}'
    )
    # Beide Histogramme in einer Figure
    fig = go.Figure([orig_hist, filtered_hist])
    fig.update_layout(
        barmode='overlay',
        xaxis_title='Price',
        yaxis_title='Count',
        title='Distribution of Price (Vergleich Original & Gefiltert)',
        height=450 #600
    )
    fig.update_xaxes(
        tickmode='linear',
        tick0=0,
        dtick=2000
    )
    mystr = f"price_start: {slider_value_l}, price_end: {slider_value_r}, row_count: {row_count} ( should be > 60)"
    return fig, mystr


@app.callback(
    Output('rel_histogram', 'figure'),
    Output('scatter_plot', 'figure'),
    Output('output_trained', 'value'),
    Input('refresh_button', 'n_clicks')
)
def update_rel_histogram(n_clicks):
    import plotly.graph_objects as go
    global model_train, label_encoders_train,scaler_train, mse_train, r2_square_train, df_pred_train
    global df_filtered
    global slider_trained_l, slider_trained_r

    # start the modeltraining
    if n_clicks and n_clicks > 0 and row_count >=60 :        
       model_train, label_encoders_train,scaler_train, mse_train, r2_square_train, df_pred_train = training_carmodel(
            df_filtered, categorical_columns, numerical_columns, 2, test_daten_size=0.2, squared_cols=0
        )
        # save the price range  for price prediction     
       slider_trained_l= slider_value_l
       slider_trained_r= slider_value_r

    # print("r2_score:",  r2_square_train, "mse:", mse, min.:",df_pred_train['rel%'].min(), "max.:",df_pred_train['rel%'].max(), "mean.:",df_pred_train['rel%'].mean())  

    my_outstr = (
    f"r2_score: {r2_square_train:.4f}, "
    f"mse: {mse:.4f}, "
    f"min.%: {df_pred_train['rel%'].min():.4f}, "
    f"max.%: {df_pred_train['rel%'].max():.4f}, "
    f"mean%.: {df_pred_train['rel%'].mean():.4f}"
    )

    #print(my_outstr)

    rel_hist = go.Histogram(
            x= df_pred_train['rel%'],
            xbins=dict(size=5),
            nbinsx=100,
            opacity=0.5,
            name='relative in %'
        )
    fig = go.Figure(rel_hist)
    #fig.update_layout(title='relative Abweichung')
    fig.layout=go.Layout(height=400, 
                         width=700, 
                         title='Histogram: Die Häufigkeit der rel%-Abweichung',
                         xaxis_title='Relative Abweichung [%]',
                         yaxis_title='Häufigkeit'
                                   )
                                                     

    #--------------------
    scatter_plt = go.Scatter(
                x=df_pred_train['Actual Value'],
                y=df_pred_train['rel%'],
                mode='markers',
                opacity=0.7,
                marker=dict(color='blue')
                )

    fig1 = go.Figure(scatter_plt)
    fig1.update_layout(
                title='Scatterplot: y_test(Preis in $) vs. rel% Abweichung',
                xaxis_title='y_test (echte Werte in $)',
                yaxis_title='Relative Abweichung [%]',
                height=400,
                width=700
                  )

  #---------------------------
    
    return fig, fig1, my_outstr


if __name__ == '__main__':
    app.run(debug=True, port=8050)

import dash
from dash import dcc, html, Input, Output, State
import dash_bootstrap_components as dbc

# Initialisiere die Dash-App
app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])

# Initialwerte
initial_value_3 = 0
initial_value_4 = 0
app.layout = dbc.Container([
    html.H1("Dashboard für Preisvoraussage", className="my-4 text-center"),

    dbc.Row([
        # Spalte 1: Inputs
        dbc.Col(dbc.Card([
            dbc.CardHeader("Eingaben"),
            dbc.CardBody([
                html.Div([
                    html.Label("Preiseingeben"),
                    dcc.Input(
                        id='price_input',
                        type='text',
                        placeholder='10000', 
                        value='10000', 
                        style={'width': '100%'}
                    ),
                ], className="mb-3"),

                html.Div([
                    html.Label("Motorleistung"),
                    dcc.Input(
                        id='ps_value',
                        type='number',
                        value=initial_value_3,
                        style={'width': '100%'}
                    ),
                ], className="mb-3"),

                html.Div([
                    html.Label("Motorgröße"),
                    dcc.Input(
                        id='motor_size',
                        type='number',
                        value=initial_value_4,
                        style={'width': '100%'}
                    ),
                ], className="mb-3"),

                dbc.Button("Preis berechnen", id='action-button', n_clicks=0, 
                           color="primary", className="w-100"),
            ])
        ]), width=3),

        # Spalte 2: Parameter-Info: part 1
        dbc.Col(dbc.Card([
            dbc.CardHeader("Auto-Parameter"),
            dbc.CardBody([
                dcc.Textarea(
                    id='parameter_info',
                    readOnly=True,
                    value='',                   
                    style={
                        'width': '100%',
                        'height': '350px',
                        'backgroundColor': '#f0f0f0',
                        'resize': 'vertical'
                    }                    
                ),
            ])
        ]), width=3),

        # Spalte 3: Parameter-Info: part 2
        dbc.Col(dbc.Card([
            dbc.CardHeader("Auto-Parameter"),
            dbc.CardBody([
                dcc.Textarea(
                    id='parameter_info1',
                    readOnly=True,
                    value='',                   
                    style={
                        'width': '100%',
                        'height': '350px',
                        'backgroundColor': '#f0f0f0',
                        'resize': 'vertical'
                    }                    
                ),
            ])
        ]), width=3),

        
        # Spalte 4: Ergebnisse
        dbc.Col(dbc.Card([
            dbc.CardHeader("Ergebnisse"),
            dbc.CardBody([
                html.Div([
                    html.Label("Vorausgesagter Preis"),
                    dcc.Input(
                        id='price_pred',
                        type='text',
                        readOnly=True,
                        value='Warte auf Button-Klick',
                        style={'width': '100%', 'backgroundColor': '#f0f0f0'}
                    ),
                ], className="mb-3"),

                html.Div([
                    html.Label("Preis-Differenz"),
                    dcc.Input(
                        id='price_diff',
                        type='text',
                        readOnly=True,
                        value='Warte auf Button-Klick',
                        style={'width': '100%', 'backgroundColor': '#f0f0f0'}
                    ),
                ]),
            ])
        ]), width=3),
    ]),
], fluid=True)


# Callback für Nr. 1 und Nr. 2
# Wenn Enter in input-1 gedrückt wird, wird der Wert in output-2 aktualisiert.
# price_input  1
# parameter_info 2
# ps_value 3
# motor_size 4
# action-button
# price_pred  5
# price_diff  6

@app.callback(
    Output('parameter_info', 'value'),
    Output('parameter_info1', 'value'),
    Output('ps_value', 'value'),
    Output('motor_size', 'value'),
    Input('price_input', 'n_submit'),
    State('price_input', 'value'),
    #prevent_initial_call=True 
)
def update_para_ps_engine_size(n_submit, price_input_value):
    #slider_trained_l, slider_trained_r
    global item_car_info
    
    if not price_input_value:
        return "Bitte Preis eingeben"
    # use orig df, df_filtered_pred_new is no allowed to change   
    df_filtered_pred_new = df[(df['price'] >= slider_trained_l) & (df['price'] <= slider_trained_r)]
    price_val = float(price_input_value) # string to float
    len_pred_new = len(df_filtered_pred_new)
    # search for item in df_filtered_pred_new
    idx_nearest = None
    price_nearest = None

    # search for the nearst price index
    idx_nearest = (df_filtered_pred_new['price'] - price_val).abs().idxmin()
    
    price_nearest = df.loc[idx_nearest, 'price']
    #print(idx_nearest, price_nearest)
    ps_val= df.loc[idx_nearest, 'horsepower']
    motor_size_val= df.loc[idx_nearest, 'enginesize']
    
    item_info_str = []
    parts_str=[]
    run_idx = 0
    
    if idx_nearest is not None:
        item_car_info = df_filtered_pred_new.loc[idx_nearest] 
        #print("item_car_info: type", type(item_car_info))
        for col, val in item_car_info.items():
          item_info_str = '\n'.join(f"{col}:   {val}" for col, val in item_car_info.items())
        parts_str = item_info_str.split("enginetype", 1)
        parts_str[1]='enginetype'+ parts_str[1]
        
    #item_info_str = '\n'.join(f"{col}: {val}" for col, val in item_info.items())
               

    return parts_str[0], parts_str[1], str(ps_val), str(motor_size_val)

# Callback für den Button und Felder 5 & 6
# Der Button löst eine Aktion aus, die die Werte in Feld 5 und 6 aktualisiert.
@app.callback(
    Output('price_pred', 'value'),
    Output('price_diff', 'value'),
    Input('action-button', 'n_clicks'),
    State('ps_value', 'value'), # Werte von input-3 und input-4 als State übergeben
    State('motor_size', 'value'),
    prevent_initial_call=True
)
def update_fields_on_button_click(n_clicks, value_3, value_4):
    if n_clicks is None:
        # Dies sollte wegen prevent_initial_call=True nicht direkt beim Start passieren
        # Kann aber hilfreich sein, wenn der Button noch nicht geklickt wurde
        return dash.no_update, dash.no_update
    #print("n_clicks", n_clicks)
    # Hier definierst du die Logik für die Aktualisierung der Felder 5 und 6
    # Basierend auf den Werten aus Feld 3 und 4
    try:
        val3 = float(value_3)
        val4 = float(value_4)
    except (ValueError, TypeError):
        return "Ungültiger Wert", "Ungültiger Wert"

    item_car_info['horsepower']  = val3
    item_car_info['enginesize']  = val4
    #print(item_car_info['horsepower'])
    #print(item_car_info['enginesize'])
       
    #model_train, label_encoders_train,scaler_train, mse_train, r2_square_train, df_pred_train = training_carmodel(
    #       df_filtered, categorical_columns, numerical_columns, 2, test_daten_size=0.2, squared_cols=0
    
    df_item_car_info = pd.DataFrame([item_car_info]) # df_item_car_info: as a DataFrame
    price_before= item_car_info['price']
    price_predicted= predict_price(df_item_car_info, model_train, label_encoders_train, scaler_train, 
                                   categorical_columns, numerical_columns,squared_cols=0)
    
    #print("price_pred_str:", price_predicted)
    #print("price_before:", price_before)
    price_pred_dff= price_predicted[0] - price_before
    price_predicted_str= str(int(price_predicted[0]))
    price_pred_dff_str= str(int(price_pred_dff))

  
    return price_predicted_str, price_pred_dff_str


# Run the app
if __name__ == '__main__':
    app.run(debug=True, port=8051)

Fahrzeugsegment	Beschreibung	Typische Preisspanne (Neuwagen)	Bemerkungen zu Kosten
A-Segment	Kleinstwagen, sehr kompakt, ideal für Stadtverkehr	unter 15.000 €	Günstig in Anschaffung und Unterhalt
B-Segment	Kleinwagen, etwas größer, alltagstauglicher, mehr Komfort	15.000 – 25.000 €	Kompromiss zwischen Preis und Platz/Komfort
C-Segment	Kompaktklasse, familienfreundlich, gute Mischung aus Platz und Ausstattung	20.000 – 35.000 €	Vielseitig, gute Ausstattung
D-Segment	Mittelklasse, komfortabler, bessere Ausstattung	ab ca. 35.000 €	Höhere Anschaffungskosten
Oberklasse / Luxus	Große und luxuriöse Fahrzeuge	ab ca. 50.000 €	Teuer, höherer Unterhalt, Luxusausstattung

Methode	Zweck / Was sie zeigt	Warum sinnvoll für Data Analysts
`df.info()`	Gibt Spaltennamen, Datentypen, Anzahl nicht fehlender Werte und Speicherverbrauch aus	Schneller Überblick über Datentypen, fehlende Werte und Speicherbedarf. Hilft bei der Datenvorbereitung.
`df.describe()`	Statistische Kennzahlen numerischer Spalten: count, mean, std, min, 25%, 50%, 75%, max	Erkennt Verteilungen, Ausreißer und zentrale Tendenzen. Grundlage für Transformationen und Feature Engineering.
`df.nunique()`	Anzahl der eindeutigen Werte pro Spalte	Identifikation von kategorialen Spalten, Variabilität von Features, Erkennen von konstanten oder redundanten Spalten.
`df.isna().sum()`	Anzahl der fehlenden Werte (`NaN`) pro Spalte	Hilft, Spalten mit fehlenden Daten schnell zu identifizieren, Planung von Imputation oder Bereinigung der Daten.

	car_ID	symboling	wheelbase	carlength	carwidth	carheight	curbweight	enginesize	boreratio	stroke	compressionratio	horsepower	peakrpm	citympg	highwaympg	price
doornumber
four	112.965217	0.104348	101.133913	178.388696	66.300000	54.915652	2646.260870	127.669565	3.358261	3.252348	10.766087	99.686957	5020.869565	25.147826	30.530435	13501.152174
two	90.266667	1.766667	95.718889	168.504444	65.406667	52.203333	2439.677778	125.933333	3.293333	3.259333	9.345778	109.777778	5258.333333	25.311111	31.033333	12989.924078

	car_ID	symboling	doornumber	wheelbase	carlength	carwidth	carheight	curbweight	cylindernumber	enginesize	boreratio	stroke	compressionratio	horsepower	peakrpm	citympg	highwaympg	price
count	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000	205.000000
mean	103.000000	0.834146	3.121951	98.756585	174.049268	65.907805	53.724878	2555.565854	4.380488	126.907317	3.329756	3.255415	10.142537	104.117073	5125.121951	25.219512	30.751220	13276.710571
std	59.322565	1.245307	0.994966	6.021776	12.337289	2.145204	2.443522	520.680204	1.080854	41.642693	0.270844	0.313597	3.972040	39.544167	476.985643	6.542142	6.886443	7988.852332
min	1.000000	-2.000000	2.000000	86.600000	141.100000	60.300000	47.800000	1488.000000	2.000000	61.000000	2.540000	2.070000	7.000000	48.000000	4150.000000	13.000000	16.000000	5118.000000
25%	52.000000	0.000000	2.000000	94.500000	166.300000	64.100000	52.000000	2145.000000	4.000000	97.000000	3.150000	3.110000	8.600000	70.000000	4800.000000	19.000000	25.000000	7788.000000
50%	103.000000	1.000000	4.000000	97.000000	173.200000	65.500000	54.100000	2414.000000	4.000000	120.000000	3.310000	3.290000	9.000000	95.000000	5200.000000	24.000000	30.000000	10295.000000
75%	154.000000	2.000000	4.000000	102.400000	183.100000	66.900000	55.500000	2935.000000	4.000000	141.000000	3.580000	3.410000	9.400000	116.000000	5500.000000	30.000000	34.000000	16503.000000
max	205.000000	3.000000	4.000000	120.900000	208.100000	72.300000	59.800000	4066.000000	12.000000	326.000000	3.940000	4.170000	23.000000	288.000000	6600.000000	49.000000	54.000000	45400.000000

Feature	Kategorien (mit Häufigkeit)	Faktor-Überlegung / Begründung	Beispiel-Faktoren
Fueltype	Gas (185), Diesel (20)	Diesel oft teurer als Benzin	Gas = 1.0, Diesel = 1.2
Aspiration	std (168), turbo (37)	Turbo = leistungssteigernd, höherer Preis	std = 1.0, turbo = 1.3
Carbody	convertible (6), hardtop (8), hatchback (70), sedan (96), wagon (25)	Sedan als Basis, convertible/hardtop teurer, hatchback günstiger	sedan = 1.0, hatchback = 1.1, wagon = 1.2, convertible = 2.0, hardtop = 2.3
Drivewheel	fwd (120), rwd (76), 4wd (9)	fwd = Standard, rwd = sportlicher/teurer, 4wd selten/luxus	fwd = 1.0, rwd = 1.2, 4wd = 2.0
Enginelocation	front (202), rear (3)	Rear = selten, meist Sportwagen → teurer	front = 1.0, rear = 1.2
Enginetype	ohc (148), dohc (12), dohcv (1), l (12), ohcf (15), ohcv (13), rotor (4)	ohc = Standard, andere Bauarten seltener/teurer	ohc = 1.1, l = 1.0, dohc = 1.3, dohcv = 1.4, ohcf = 1.1, ohcv = 1.2, rotor = 1.5
Fuelsystem	mpfi (94), 2bbl (66), idi (20), 1bbl (11), spdi (9), 4bbl (3), mfi (1), spfi (1)	mpfi als Basis, seltenere Systeme teurer oder spezieller	mpfi = 1.0, 2bbl = 1.1, idi = 1.3, 1bbl = 1.5, spdi = 1.7, 4bbl = 1.4, mfi = 1.6, spfi = 1.8

	car_ID	symboling	CarName	fueltype	aspiration	doornumber	carbody	drivewheel	enginelocation	wheelbase	carlength	carwidth	carheight	curbweight	enginetype	cylindernumber	enginesize	fuelsystem	boreratio	stroke	compressionratio	horsepower	peakrpm	citympg	highwaympg	price
0	1	3	alfa-romero giulia	gas	std	two	convertible	rwd	front	88.6	168.8	64.1	48.8	2548	dohc	four	130	mpfi	3.47	2.68	9.0	111	5000	21	27	13495.0
1	2	3	alfa-romero stelvio	gas	std	two	convertible	rwd	front	88.6	168.8	64.1	48.8	2548	dohc	four	130	mpfi	3.47	2.68	9.0	111	5000	21	27	16500.0
2	3	1	alfa-romero Quadrifoglio	gas	std	two	hatchback	rwd	front	94.5	171.2	65.5	52.4	2823	ohcv	six	152	mpfi	2.68	3.47	9.0	154	5000	19	26	16500.0
3	4	2	audi 100 ls	gas	std	four	sedan	fwd	front	99.8	176.6	66.2	54.3	2337	ohc	four	109	mpfi	3.19	3.40	10.0	102	5500	24	30	13950.0
4	5	2	audi 100ls	gas	std	four	sedan	4wd	front	99.4	176.6	66.4	54.3	2824	ohc	five	136	mpfi	3.19	3.40	8.0	115	5500	18	22	17450.0

Aspekt	IQR (Whisker)	3σ-Methode
Basis	Quartile (Q1, Q3)	Mittelwert & Standardabweichung
Robustheit	Sehr robust gegenüber Ausreißern	Weniger robust, Ausreißer beeinflussen σ
Verteilung	Keine Annahmen	Annahme: Normalverteilung
Typische Erkennung	Werte >1.5×IQR vom Quartil entfernt	Werte >3σ vom Mittelwert entfernt
Sensitivität	Moderate Ausreißer	Extreme Ausreißer bei Normalverteilung

Feature (Merkmal)	Korrelation	Richtung
enginesize (Motorgröße)	0.87	positiv
curbweight (Leergewicht)	0.84	positiv
horsepower (PS)	0.81	positiv
carwidth (Fahrzeugbreite)	0.76	positiv
cylindernumber (Zylinderanzahl)	0.72	positiv
highwaympg (Verbrauch Autobahn)	-0.71	negativ
citympg (Verbrauch Stadt)	-0.70	negativ
carlength (Fahrzeuglänge)	0.68	positiv
wheelbase (Radstand)	0.57	positiv
boreratio (Bohrungsverhältnis)	0.55	positiv
carheight (Fahrzeughöhe)	0.11	positiv
peakrpm (max. Drehzahl)	-0.09	negativ
stroke (Hub)	0.08	positiv
compressionratio (Verdichtungsverhältnis)	0.07	positiv
doornumber (Anzahl der Türen)	0.02	positiv

carbody	enginetype
sedan	ohc
hatchback	l
wagon	dohc
convertible	dohcv
hardtop	ohcv
sedan	rotor

carbody_convertible	carbody_hardtop	carbody_hatchback	carbody_sedan	carbody_wagon	enginetype_dohc	enginetype_dohcv	enginetype_l	enginetype_ohc	enginetype_ohcv
0	0	0	1	0	0	0	0	1	0
0	0	1	0	0	0	0	1	0	0
0	0	0	0	1	1	0	0	0	0
1	0	0	0	0	0	1	0	0	0
0	1	0	0	0	0	0	0	0	1

Kriterium	Label Encoding	One-Hot Encoding
Darstellung	Jede Kategorie → eine Zahl	Jede Kategorie → eigene Spalte mit 0/1
Speicherbedarf	Sehr gering (nur eine Spalte)	Höher (eine Spalte pro Kategorie)
Interpretation	Problematisch: Modell denkt, Zahlen hätten Reihenfolge	Klar & eindeutig, keine künstliche Reihenfolge
Gut für	Entscheidungsbäume, Random Forest	Lineare Modelle, Neuronale Netze
Schlecht für	Lineare Modelle (da künstliche Rangordnung)	Viele Kategorien (führt zu sehr breiten Matrizen)

Aspekt	OneHotEncoder (sklearn)	pd.get_dummies() (pandas)
Output	NumPy-Array oder DataFrame (mit Zusatzschritt)	Direkt ein Pandas-DataFrame
Wiederverwendbar	✅ Ja (fit/transform für neue Daten)	❌ Nein (funktioniert nur auf vorhandenen Daten)
Integration in Pipeline	✅ Sehr gut (für ML-Workflows in sklearn)	❌ Nicht vorgesehen
Drop-First Option	Standardmäßig ❌ (aber man kann `drop="first"` setzen)	✅ `drop_first=True` verfügbar
Einfache Anwendung	etwas mehr Code (fit/transform nötig)	sehr einfach, 1 Zeile

Feature-Typ	Training	Vorhersage	Warum wichtig
Numerisch	`fit_transform()`	`transform()`	Konsistente Standardisierung
Kategorial (Ordinal)	`fit_transform()` + Encoder speichern	`transform()` mit gespeichertem Encoder	Konsistente Kodierung

Faktor	Effekt auf Modellleistung
One-Hot, unterschiedliche Anzahl Kategorien	Spalten mit vielen Dummies dominieren; kleine Spalten werden schwach gewichtet
drop_first=True	Kann bei kleinen Datensätzen Informationsverlust erzeugen
Label-Encoding, wenige Kategorien	Modell kann Rangordnung leicht lernen; Zahlenunterschied klein → kompakter und stabiler

Methode	R² Score	MSE	rel. min.	rel. max.	rel. mean.
One-Hot-Encoding	0.7505	19,693,826.14	1.47	86.35	31.83
Ordinal-Encoding	0.8660	10,580,608.45	0.22	72.77	16.96
Ordinal-Encoding - Ausreißer	0.8771	12,637,217.35	1.77	57.74	15.15
Ordinal-Encoding + Sqrt()	0.8919	11,117,848.75	0.61	41.78	14.71

Feature	Kategorien
fueltype	gas, diesel
fuelsystem	mpfi, 2bbl, mfi, 1bbl, spfi, 4bbl, idi, spdi
carbody	convertible, hatchback, sedan, wagon, hardtop
drivewheel	rwd, fwd, 4wd
enginelocation	front, rear
enginetype	dohc, ohcv, ohc, l, rotor, ohcf, dohcv
brand	alfa-romero, audi, bmw, chevrolet, dodge, honda, isuzu, jaguar, maxda, mazda, buick, mercury, mitsubishi, Nissan, nissan, peugeot, plymouth, porsche, porcshce, renault, saab, subaru, toyota, toyouta, vokswagen, volkswagen, vw, volvo

carbody_convertible	carbody_hardtop	carbody_hatchback	carbody_sedan	carbody_wagon	enginetype_dohc	enginetype_dohcv	enginetype_l	enginetype_ohc	enginetype_ohcv
0	0	0	1	0	0	0	0	1	0
0	0	1	0	0	0	0	1	0	0
0	0	0	0	1	1	0	0	0	0
1	0	0	0	0	0	1	0	0	0
0	1	0	0	0	0	0	0	0	1

Abschlußprojekt für Data Analyst: Entwicklung eines Autopreisvorhersagemodells und Integration in ein Dashboard zur Anwendung.¶

Autor Guangfa Wu, 18.08.2025, Stuttgart¶

Daten: https://www.kaggle.com/datasets/hellbuoy/car-price-prediction¶

Projektidee, Beschreibung:¶

Problembeschreibung: Autopreis vorhersagen¶

Das Unternehmen möchte wissen:¶

Vorgegensweise:¶

CRISP-DM wird angewendet¶

Anwendung:¶

Das Modell soll dem Management dabei helfen zu verstehen:¶

Der bereitgestellte Datensatz dient ausschließlich zu Lernzwecken. Ziehen keine Rückschlüsse auf reale Märkte oder tatsächliche Marktbedingungen.¶

Die Arbeitsschritte richten sich nach CRISP-DM¶

1. Business Understanding (Aufgabendefinition)¶

Fahrzeugsegmente und Preisspannen¶

🚗 Übersicht gängiger Fahrzeugsegmente¶

📌 Relevanz für die Analyse¶

Datenquelle:¶

CarPrice_Assignment.csv¶

Information von Auto: 26 Spalten¶

Einlesenvon Daten aus der csv-Datei:¶

2. Data Understanding (Auswahl der relevanten Datenbestände)¶

2.1 Deskriptive Analyse¶

🔎 Erste Methoden für einen Überblick¶

2.1.1 Die Methode df.info() in Pandas¶

📌 Ergebnisse für die Projektdaten¶

2.1.2 Check NAN: Ergebnis:keine NaN vorhanden. Die Behandlung von NaN entfällt.¶

2.1.3 Untersuchung von cylindernumber und doornumber: sind als Kategorie angegeben, in Zahl umwandeln¶

Anwendungvon df.describe()¶

Warum ist df.describe() sinnvoll für Data Analysts?¶

1. Schneller Überblick über die Daten¶

2. Datenqualität prüfen¶

3. Vergleich zwischen Spalten¶

Überblick über die Anzahl der eindeutigen Werte (unique values)¶

📌 Warum ist df.nunique() sinnvoll für die Datenanalyse?¶

2.1.4 Erstellung von Histogrammen für numerische Werte¶

2.1.4.1 Analyse der Histogramme der Fahrzeugmerkmale¶

Aussage über die Verteilung:¶

2.1.4.2 Zusammenfassende Beobachtungen¶

2.1.5 Histogram von Autopreisen: hier von besonderem Interesse¶

Min.: 5118€¶

Max.: 45400€¶

mean: 13276€¶

midian: 10295€¶

2.1.6 Bar-Darstellung der kategorischen Daten¶

2.1.7 Überblick über die Autohersteller:¶

2.1.8 Berechnung von Durchschnittpreis für Top-20 Autohersteller¶

2.1.9 Durchschnittspreise der Hersteller im unteren Preissegment (günstigste 20 Autohersteller)¶

2.1.10 Kategorische Merkmale vs. Preis: Boxplot¶

Der Boxplot ist ein zentrales Werkzeug in der Datenanalyse. Er visualisiert die Verteilung von Daten und macht wichtige Eigenschaften wie Lage, Streuung und mögliche Ausreißer auf einen Blick erkennbar.¶

Zusammenhang zwischen Whisker und 3-facher Standardabweichung¶

1️⃣ Whisker (Boxplot) – IQR-Methode¶

2️⃣ 3-fache Standardabweichung – Z-Score-Methode¶

3️⃣ Vergleich / Zusammenhang¶

2.1.11 Numerische Werte mit Bar-Darstellung¶

2.2 Explorative Datenanalyse (EDA)¶

2.2.1 Streudiagramm: Preis (y-Achse) vs. numerische Spalte (x-Achse)¶

Interpretation der Scatterplots (Features vs. Preis)¶

1. Abmessungen¶

2. Gewicht & Motorgröße¶

3. Motorcharakteristik¶

4. Verbrauchswerte¶

5. Karosserie & Türen¶

✅ Gesamtbewertung¶

2.2.2 Korrelationskarte (Heatmap)¶

1. Correlation Map of numerical_columns¶

2. Warum ist das gut?¶

3. Korrelation der Features mit dem Fahrzeugpreis¶

4. Analyse der Korrelationen mit dem Fahrzeugpreis¶

3. Data Preparation (Datenaufbereitung)¶

3.1. Datenbereinigung¶

3.2. Umwandlung von kategorischen Daten in numerischen Daten¶

3.3. Zerlegung von kategorischen Daten in zwei Spalten: brand und model¶

3.4. Anwendung von log(y),sqrt(y), x^2 usw. auf bestimmten Spalten: x: Preis, y: Werte in der Spalten¶

3.5. Analyse von Ausreißern in citympg und highwaympg¶

3.5.1 Statistische Betrachtung:¶

3.5.2 Analyse von citympg und highwaympg:¶

3.5.3 Löschbedingung von Ausreißern: Spalte:'highwaympg'¶

mean: 30.75121951219512¶

std: 6.886443130941824¶

limit_right: mean+3*std=30.75+3 x 6.88(20.64)= ca. 52; Werte > 52 werden gelöscht: nur zwei Werte 53, 54 betroffen¶

Daten: https://www.kaggle.com/datasets/hellbuoy/car-price-prediction ¶

CarPrice_Assignment.csv ¶

2.1.1 Die Methode `df.info()` in Pandas¶

Anwendungvon `df.describe()`¶

Warum ist `df.describe()` sinnvoll für Data Analysts?¶

Überblick über die Anzahl der eindeutigen Werte (`unique values`)¶

📌 Warum ist `df.nunique()` sinnvoll für die Datenanalyse?¶

1. Correlation Map of `numerical_columns`¶

2️⃣ Einfluss von `drop_first=True`¶

carbody_convertible	carbody_hardtop	carbody_hatchback	carbody_sedan	carbody_wagon	enginetype_dohc	enginetype_dohcv	enginetype_l	enginetype_ohc	enginetype_ohcv
0	0	0	1	0	0	0	0	1	0
0	0	1	0	0	0	0	1	0	0
0	0	0	0	1	1	0	0	0	0
1	0	0	0	0	0	1	0	0	0
0	1	0	0	0	0	0	0	0	1